//配置layui插件目录
layui.config({
    base: 'js/module/',
    version: '2.5.5'
}).extend({
});
layui.use(['element', 'table', 'form', 'tableCheckBoxUtil','layer'], function() {
    var element = layui.element,
        table = layui.table,
        form = layui.form,
        tableCheckBoxUtil = layui.tableCheckBoxUtil,
        layer = layui.layer;

    /**
     * 表格功能全局调用方式
     * layui table 设置filter:true之后，插件调用功能。
     */
    $.fn.layuiTableEvent = function(options) {
        var defaults = {
            filterHead: true, //当表格只做简单展示，无筛选条件，只有原生排序功能，也不需展示排序条件，关闭筛选条件层显示，默认开启
            filterHeadShow:false,//显示筛选条件层，默认初始不显示。
        }

        this.each(function() {
            //var that = $(this);
            var config = $.extend({}, defaults, options)
            //console.log('%c=== index.js接收的配置参数 ===\n', 'background:red;color:#000', config)

            var _columnName, //表单当前点击筛选列名称
                _fieldName = config.checked, //数据字段第一个名称，如'specimen_id',用于跨页选择使用
                that = $('.' + config.table_class), //表格父容器
                _whereParams = new Object(); //查询表格参数

            //创建筛选条件层
            var _filterConditionStyle = '';
            if(!config.filterHeadShow) {
                _filterConditionStyle = 'style="display:none;"';
            }
            var creatFilterCondition = '<div class="layui-filter-condition"'+_filterConditionStyle+'><div><i class="iconfont">&#xe62a;</i></div><div><ul><li>筛选条件：</li><li class="filter-c"><p></p><a class="reset">清除筛选条件</a></li></ul><ul><li>排序条件：</li><li class="sort-c"><p></p><a class="reset">清除排序条件</a></li></ul></div></div>';
            if(that.find('.layui-filter-condition').length == 0){
                that.prepend(creatFilterCondition).css('display','block');
            }else{
                that.find('.layui-filter-condition').remove();
                that.prepend(creatFilterCondition).css('display','block');
            }            
            /*
             * 如果存在filterCheckbox传参键值。
             * 头部过滤条件中创建对应列名称的input，存放已选项目
             */
            if(config.filterCheckbox){
                var o = $('<div class="filter-checkbox-input" style="display:none;"></div>').appendTo(that.find('.layui-filter-condition >div:last'));
                for(var key in config.filterCheckbox){
                    o.append('<input name="'+key+'--input" value="">')
                }
            }   

            //点击显示筛选浮层
            that.on('click', '.layui-table-filter', function(e) {
                //关闭页面中所有表格筛选弹层    
                $('.layui-table-filter-box').hide();
                $('.layui-table-header .layui-table-filter').removeClass('current');
                //添加当前状态           
                $(this).addClass('current');
                _columnName = $(this).attr('type');
                console.log('%c当前选择列 - ', 'color:orange',_columnName)
                showFilter($(this));
                e.stopPropagation();
            })

            //显示table筛选浮动层
            function showFilter(t) {
                var t1 = t.offset().top,
                    l1 = t.offset().left - 180,
                    h = t.height() + 5,
                    t2 = t.parents('.table-containter').offset().top,
                    l2 = t.parents('.table-containter').offset().left;
                //生成结构前先清除旧元素  
                t.parents('.table-containter').find('.layui-table-filter-box').html('');
                /**
                 * 一、创建筛选表单，表单不是唯一，不同列可能使用不同筛选表单，可自定义通过判断字段来选择使用，默认使用default类型查询表单
                 * 前端可指定字段显示不同的查询表单
                 *  filterForm:{
                 *      'type2':['item 1','item2'],
                 * }
                 * PS:item1、item2字段使用type2类型查询表单。
                 * 二、多选显示方式，当传参中出现filterCheckbox，并含有指定内容。则显示指定的type4模块，模块名不固定，根据传参的名称
                 * filterCheckbox:{
                 *    'type4':{
                 *        'wealth':['name1','name2','name3'],
                 *    }
                 * }
                 */
                var _o = Object.keys(config.filter)
                // console.log(_o)

                /*
                 * 获取采用checkbox方式的模块名称
                 *
                */
                var isCheckboxFilter = false;//是否多选过滤
                if(config.filterCheckbox){
                    for(var key in config.filterCheckbox){
                        var filterCheckboxModule = key;
                        //如果当前点击的列 在 filterCheckbox 参数中，显示checkbox结构
                        if(filterCheckboxModule == _columnName){
                            isCheckboxFilter = true;
                            break;
                        }
                    }
                }
                if(isCheckboxFilter){
                    // console.log('我是多选')
                    var _arr = eval('config.filterCheckbox.'+_columnName);//传参中，列名称中带的数组
                    var _val = that.find('.layui-filter-condition input[name="'+_columnName+'--input"]').val();//获取过滤条件中保存的对应字段
                    // console.log(_val)
                    var _C_arr = new Array();
                    if(_val) _C_arr = _val.split(',');
                    // console.log(_C_arr);
                    var _list = '';
                    var _allChecked = true;//全部勾选
                    $.each(_arr,function(i,d){
                        //过滤条件中已有值，添加勾选标记
                        if(_val){
                            if(_C_arr.indexOf(d) > -1){
                                _list += '<li><input type="checkbox" name="" lay-skin="primary" title="'+d+'" value="'+d+'" checked lay-filter="TABLE-FILTER-C-N-S"></li>';
                            }else{
                                _list += '<li><input type="checkbox" name="" lay-skin="primary" title="'+d+'" value="'+d+'"  lay-filter="TABLE-FILTER-C-N-S"></li>';
                                _allChecked = false;
                            }

                        }else{
                            _list += '<li><input type="checkbox" name="" lay-skin="primary" title="'+d+'" value="'+d+'"  lay-filter="TABLE-FILTER-C-N-S"></li>';
                            _allChecked = false;
                        }
                    })

                    //已全选，设置全选状态
                    if(_allChecked){
                        var _allCheckedDom = '<input type="checkbox" lay-skin="primary" title="全选" lay-filter="TABLE-FILTER-C-N-S-ALL" checked>';
                    }else{
                        var _allCheckedDom = '<input type="checkbox" lay-skin="primary" title="全选" lay-filter="TABLE-FILTER-C-N-S-ALL">';
                    }

                    t.parents('.table-containter').find('.layui-table-filter-box').html(''+
                        '<form class="layui-form">'+
                        '   <div class="layui-form-item">'+
                        '       <div class="layui-box">过滤</div>'+
                        '   </div>'+            
                        '   <div class="">'+
                        '       <input type="text" placeholder="搜索" autocomplete="off" class="layui-input filter-checkbox-search">'+
                        '   </div>'+ 
                        '   <div class="layui-form-item">'+  
                        '       '+_allCheckedDom+''+ 
                        '       <ul style="max-height:160px;overflow-y:auto;">'+_list+'</ul>'+ 
                        '   </div>'+       
                        '   <div class="layui-form-item">'+
                        '       <div class="layui-block">'+
                        '           <button class="layui-btn layui-btn-sm" lay-submit lay-filter="filter-checkbox">确定</button>'+
                        '           <button type="button" class="layui-btn layui-btn-primary layui-btn-sm close">取消</button>'+
                        '       </div>'+
                        '   </div>'+
                        '</form>');
                }else{
                    // console.log('我就正常的显示')
                    addFilterDom();
                }
                //添加筛选结构
                function addFilterDom(){
                    //如果列有指定的过滤结构，显示对应的元素，否则都默认显示default结构
                    if (config.filterForm && JSON.stringify(config.filterForm) != '{}') {
                        for(var key in config.filterForm){
                            //console.log(eval('config.filterForm.'+key))
                            var _K = eval('config.filterForm.'+key);
                            if (_K && _K.length > 0) {
                                //判断当前选择列name，是否在指定的数组中
                                if (_K.indexOf(_columnName) > -1) {
                                    var _E = eval("config.filter." + key);
                                    console.log('%c当前列指定的过滤结构类型','color:orange;',key)
                                    t.parents('.table-containter').find('.layui-table-filter-box').html(_E);
                                    break;
                                }else{
                                    //默认显示default类型
                                    t.parents('.table-containter').find('.layui-table-filter-box').html(config.filter.default);
                                }
                            } else {
                                //默认显示default类型
                                t.parents('.table-containter').find('.layui-table-filter-box').html(config.filter.default);
                            }                        
                        }
                    } else {
                        t.parents('.table-containter').find('.layui-table-filter-box').html(config.filter.default);
                    }
                }

                form.render();
                //筛选浮层定位显示
                t.parents('.table-containter').find('.layui-table-filter-box').css({ 'left': l1 - l2, 'top': t1 - t2 + h }).show();
                t.parents('.table-containter').find('.layui-table-filter-box').find('input[type=text]:nth-child(1)').focus();

                formSubmit(); //提交筛选表单
                // formSort(); //自定义排序
                formCheckbox(t);//监听列过滤浮层中的checkbox
            }

            /* 点击table筛选结构之外，关闭筛选 */
            $(document).on('click', function(e) {
                var _con = $('.layui-table-filter-box'); // 设置目标区域
                if (!_con.is(e.target) && _con.has(e.target).length === 0) {
                    closeMytableFilterPopup(); /*关闭table filter 浮动层*/
                }
            });

            /* 关闭table filter 浮动层*/
            function closeMytableFilterPopup() {
                $('.layui-table-filter-box').hide();
                that.find('.layui-table-header .layui-table-filter').removeClass('current');
            };

            /* 监听列过滤浮层中的checkbox*/
            function formCheckbox(t){
                form.on('checkbox(TABLE-FILTER-C-N-S)',function(data){
                    checkboxState(data.othis)
                })
                //全选
                form.on('checkbox(TABLE-FILTER-C-N-S-ALL)',function(data){
                    if(data.elem.checked){
                        // console.log($(data.othis).next('ul').find('li:visible'))
                        $.each($(data.othis).next('ul').find('li:visible'),function(i,d){
                            $(d).find('input[type="checkbox"]').prop('checked',true);
                        })
                    }else{
                        $.each($(data.othis).next('ul').find('li:visible'),function(i,d){
                            $(d).find('input[type="checkbox"]').prop('checked',false);
                        })
                    }
                    checkboxState(data.othis)
                })
                //遍历已选项
                function checkboxState(othis){
                    var _C_arr2 = new Array();
                    var item = $(othis).parents('.layui-form-item').find('ul li:visible input[type="checkbox"]');
                    var all = item.length;
                    for(var i=0;i<item.length;i++){
                        if(item[i].checked == false){
                            $(othis).parents('.layui-form-item').find('input[title="全选"]').prop('checked',false);
                            break;                            
                        }
                    }
                    for(var i=0;i<item.length;i++){
                        if(item[i].checked == true){
                            all--;
                            _C_arr2.push(item[i].value);
                        }
                    }
                    if(all == 0){
                        $(othis).parents('.layui-form-item').find('input[title="全选"]').prop('checked',true);
                    }
                    setTimeout(function(){
                        form.render('checkbox');
                    })
                }
                //确定
                form.on('submit(filter-checkbox)',function(data){
                    var _C_arr3 = new Array();
                    var item = $(data.elem).parents('.layui-form-item').prev().find('ul input[type="checkbox"]');
                    for(var i=0;i<item.length;i++){
                        if(item[i].checked == true){
                            _C_arr3.push(item[i].value);
                        }
                    }  
                    that.find('.layui-filter-condition input[name="'+_columnName+'--input"]').attr('value',_C_arr3);  
                    console.log(_C_arr3)
                    closeMytableFilterPopup(); //关闭table filter 浮动层
                    filterTable(); //查询表格
                    return false;
                })

                //搜索
                $('.filter-checkbox-search').keyup(function(){
                    var _val = $(this).val();
                    var _item = $(this).parent().siblings().find('ul li input:checkbox');
                    if(_val != ''){
                        $.each(_item,function(i,d){
                            if(d.title.indexOf(_val) > -1){
                                $(this).parent().show();
                            }else{
                                $(this).parent().hide();
                            }
                        })
                    }else{
                        $(this).parent().siblings().find('ul li').show();
                    }
                })
            }

            /* 监听table列筛选提交 */
            function formSubmit() {
                form.on('submit(tablePopupFilterBtn)', function(data) {
                    // console.log('筛选提交内容 : ',data.field)
                    var _minv = $(data.elem).parents('form').find('input[name="minvalue"]').val(),
                        _maxv = $(data.elem).parents('form').find('input[name="maxvalue"]').val();
                    if(Number(_minv) >= Number(_maxv)) {
                        layer.msg('最大值不能小于或等于最小值',{icon:5,anim:6});
                         $(data.elem).parents('form').find('input[type="text"]').addClass('layui-form-danger').focus();
                        return false;
                    }
                    var _filtertype; //筛选条件，通过value转义成中文，在筛选条件中显示
                    switch (data.field.tableFilterSelect) {
                        case 'like':
                            _filtertype = '模糊';
                            break;
                        case 'range':
                            _filtertype = '范围';
                            break;
                        case 'eq':
                            _filtertype = '等于';
                            break;
                        case 'neq':
                            _filtertype = '不等于';
                            break;
                        case 'in':
                            _filtertype = '包含';
                            break;
                        case 'gt':
                            _filtertype = '大于';
                            break;
                        case 'lt':
                            _filtertype = '小于';
                            break;
                        case 'egt':
                            _filtertype = '大于等于';
                            break;
                        case 'elt':
                            _filtertype = '小于等于';
                            break;
                    }

                    //将筛选项添加到筛选条件层中保存
                    if (that.find('.layui-filter-condition:hidden')) {
                        //筛选条件层初始隐藏，当有筛选事件发生，才显示条件层
                        that.find('.layui-filter-condition').show();
                        //范围查询和普通查询区分，范围查询存在  minval 和 maxval 两个值
                        var _newColumnName = _columnName.replace(/\s*/g, "");
                        if(config.def_mode == 'strict'){
                            var _A = that.find('.layui-filter-condition .filter-c p label[data-name="' + _columnName+'"]');
                        }else{
                            var _A = that.find('.layui-filter-condition .filter-c p label[data-filtertype="' + _columnName + '--' + data.field.tableFilterSelect + '"]');
                        }
                        if (data.field.tableFilterSelect == 'range') {
                            if (_A.length > 0) {
                                _A.data('minval', data.field.minvalue);
                                _A.data('maxval', data.field.maxvalue);
                                _A.find('.value').html(data.field.minvalue + ' ~ ' + data.field.maxvalue);
                            } else {
                                that.find('.layui-filter-condition .filter-c p').append('<label data-name="' + _columnName + '" data-filtertype="' + _columnName + '--' + data.field.tableFilterSelect + '" data-minval="' + data.field.minvalue + '" data-maxval="' + data.field.maxvalue + '"><span>' + _columnName + '</span> <span>' + _filtertype + '</span> <span class="value">' + data.field.minvalue + ' ~ ' + data.field.maxvalue + '</span><i class="iconfont del">&#xe7ba;</i></label')
                            }
                        } else {
                            if (_A.length > 0) {
                                _A.data('val', data.field.val);
                                _A.find('.value').html(data.field.val);
                            } else {
                                that.find('.layui-filter-condition .filter-c p').append('<label data-name="' + _columnName + '" data-filtertype="' + _columnName + '--' + data.field.tableFilterSelect + '" data-val="' + data.field.val + '"><span>' + _columnName + '</span> <span>' + _filtertype + '</span> <span class="value">' + data.field.val + '</span><i class="iconfont del">&#xe7ba;</i></label')
                            }
                        }
                    }
                    closeMytableFilterPopup(); //关闭table filter 浮动层
                    filterTable(); //查询表格
                    return false;
                });

                //列多选
                form.on('submit(selectname)',function(data){
                    console.log('子层接收')
                    closeMytableFilterPopup(); //关闭table filter 浮动层
                    filterTable();//查询表格
                    return false;
                })
            }

            /* table 中列筛选排序功能*/
            // function formSort() {
            //     $('.layui-table-filter-box .btn-sort').on('click', function() {
            //         var _type = $(this).data('type');
            //         console.log('排序方式：asc-升序，desc-降序，当前选择 - ' + _columnName + ' - ', _type)
            //         //显示筛选条件层
            //         if (that.find('.layui-filter-condition:hidden') && config.filterHead) {
            //             that.find('.layui-filter-condition').show();
            //         }
            //         closeMytableFilterPopup(); //关闭table filter 浮动层
            //         //将选择的列排序方式，添加至筛选条件中
            //         var _sortType;
            //         switch (_type) {
            //             case 'asc':
            //                 _sortType = '升序';
            //                 break;
            //             case 'desc':
            //                 _sortType = '降序';
            //                 break;
            //         }
            //         var _S = that.find('.layui-filter-condition .sort-c p label[data-name="' + _columnName + '"]');
            //         if (_S.length > 0) {
            //             _S.data('sort', _type);
            //             _S.find('.sort').html(_sortType);
            //         } else {
            //             that.find('.sort-c p').html('<label data-name="' + _columnName + '" data-sort="' + _type + '">' + _columnName + ' - <span class="sort">' + _sortType + '</span><i class="iconfont del">&#xe7ba;</i></label>');
            //         }
            //         filterTable(0); //查询表格
            //     });
            // }

            /* 监听表格工具栏 获取选中编号 显示所有数据*/
            table.on('toolbar(' + config.table_class + '_filter)', function(obj) {
                switch (obj.event) {
                    case 'getCheckData':
                        //获取选择的数据id
                        var _selectedData = tableCheckBoxUtil.getValue({
                            gridId: 'ID_' + config.table_class
                        });
                        console.log(_selectedData)
                        //筛选对象
                        _whereParams[_fieldName] = _selectedData.toString();
                        if (_selectedData != '') {
                            filterTable();//查询表格
                            layer.msg('选中的ID' + JSON.stringify(_selectedData));
                        } else {
                            layer.msg('当前没有数据选中！')
                        }
                        break;
                    case 'getAllData':
                        _whereParams[_fieldName] = ''; //清空值，返回所有数据
                        console.log('表格查询参数', _whereParams)
                        filterTable();//查询表格
                        break;
                };
            });

            //表格筛选select选择 - 模糊查询/范围查询，暂只显示单input结构和两个input结构
            function _T(param) {
                var single = '<div class="layui-form-item"><input type="text" name="val" placeholder="'+param.placeholder+'" autocomplete="off" class="layui-input" lay-verify="required|'+(param.verify?param.verify:'')+'"></div>';
                var range= '<div class="range"><div class="layui-form-item"><input type="text" name="minvalue" placeholder="请输入最小值" autocomplete="off" class="layui-input" lay-verify="required|number|rangemin"></div><div class="layui-form-item"><input type="text" name="maxvalue" placeholder="请输入最大值" autocomplete="off" class="layui-input" lay-verify="required|number|rangemax"></div></div>';
                return eval(param.type);
            }
            form.on('select(table-filter-select)', function(data) {
                switch (data.value) {
                    case 'range':
                        $(data.elem).parents('.layui-form-item').next().remove();
                        $(data.elem).parents('.layui-form-item').after(_T({type:'range'}));
                        break;
                    case 'in':
                        $(data.elem).parents('.layui-form-item').next().remove();
                        $(data.elem).parents('.layui-form-item').after(_T({type:'single',placeholder:'请输入，多个请用空格隔开'}));
                        break;
                    default:
                        $(data.elem).parents('.layui-form-item').next().remove();
                        $(data.elem).parents('.layui-form-item').after(_T({type:'single',placeholder:'请输入',verify:'number'}));
                        break;
                }
                $(data.elem).parent().parent().next().find('input[type=text]:first').focus();
            });

            //自定义验证规则,user是demo
            form.verify({
                rangemin: function(value, item) {

                },
                rangemax: function(value, item) {

                },
            })

            //清除所有筛选条件
            that.on('click', '.filter-c .reset', function() {
                var _l = $(this).parent().find('label');
                if (_l.length > 0) {
                    _l.remove();
                    for (var key in _whereParams) {
                        if (key.indexOf('_sort') == -1) {
                            delete _whereParams[key]
                        }
                    }
                    filterTable();//查询表格
                }
            });

            //清除所有排序条件
            that.on('click', '.sort-c .reset', function() {
                var _l = $(this).parent().find('label');
                if (_l.length > 0) {
                    _l.remove();
                    delete _whereParams['field'];
                    delete _whereParams['order'];
                    filterTable();//查询表格
                }
            });

            //逐个删除已有筛选条件
            that.on('click', '.filter-c label', function() {
                var _key = $(this).data('filtertype');
                //判断是否范围类查询，范围包含2个字段 min/max，需对应删除
                if (_key.indexOf('_range') < 0) {
                    delete _whereParams[_key];
                } else {
                    delete _whereParams[_key + '_min'];
                    delete _whereParams[_key + '_max'];
                }
                $(this).remove();
                filterTable();//查询表格
            });

            //逐个删除已有排序条件
            that.on('click', '.sort-c label', function() {
                delete _whereParams['field'];
                delete _whereParams['order'];
                $(this).remove();
                filterTable();//查询表格
            });           

            /**
             * 查询表格
             * 同页面中可能存在多个表格，每次查询前，从筛选条件中读取表格的查询条件，赋予 _whereParams中。
             * 每次遍历筛选条件， 重新生成查询参数进行查询
             */
            function filterTable() {
                console.log(that)
                //获取排序方式
                var _field = that.find('.layui-filter-condition .sort-c label').data('name');
                var _order = that.find('.layui-filter-condition .sort-c label').data('sort');
                if(_field && _order){
                    _whereParams['field'] = _field;
                    _whereParams['order'] = _order;                
                }else{
                    delete _whereParams['field'];
                    delete _whereParams['order'];                    
                }

                //判断是layui排序方式 object 还是自定义排序方式
                // if (typeof(sort) === 'object') {
                //     var initSortArr = sort;
                //     _whereParams['field'] = sort.field;
                //     _whereParams['order'] = sort.type;
                // } else {
                //     var initSortArr = {};
                // }

                // initSortArr['field'] = _field;
                // initSortArr['order'] = _order;

                //遍历排序条件，后台传值处理,由原生排序，自定义排序作废
                // that.find('.layui-filter-condition .sort-c p label').each(function(i, d) {
                //     var _this = $(this);
                //     _whereParams[_this.data('name') + '_sort'] = _this.data('sort');
                // });

                //遍历筛选条件，后台传值处理
                that.find('.layui-filter-condition .filter-c p label').each(function(i, d) {
                    var _this = $(this);
                    if (_this.data('minval') != undefined) {
                        _whereParams[_this.data('filtertype') + '--min'] = _this.data('minval');
                        _whereParams[_this.data('filtertype') + '--max'] = _this.data('maxval');
                    } else {
                        _whereParams[_this.data('filtertype')] = _this.data('val');
                    }
                });

                //遍历列全选功能条件,此功能可能会不开启,看传参内是否有内容
                if(config.filterCheckbox){
                    that.find('.layui-filter-condition .filter-checkbox-input input').each(function(i, d) {
                        if(d.value){
                            _whereParams[d.name] = d.value;
                        }else{
                            delete _whereParams[d.name];
                        }
                    })
                }
                clearChecked();//清除跨页选择已选项
                console.log('表格查询参数', _whereParams)
                table.reload('ID_' + config.table_class, {
                    //initSort: sort, //记录初始排序,字段名不匹配会导致报错
                    where: _whereParams,
                    page: {
                        curr: 1 //重新从第 1 页开始
                    },
                    done: function(res, curr, count) {
                        //只有自定义排序才移除其他排序状态,暂时无用
                        //this.where = {}; //查询之后，清除所有查询参数
                        if(config.filterCheckbox){
                            checkFilterCheckboxState();
                        }
                        tableCheckBox();
                        //表头title中添加当前排序状态
                        that.find('.layui-table-header th[data-field="'+_field+'"] .layui-table-sort').attr('lay-sort',_order);
                    }
                });
                //表格跨页选择插件
                function tableCheckBox(){
                    //初始化表格行选中状态
                    tableCheckBoxUtil.checkedDefault({
                        gridId: 'ID_'+config.table_class
                        , fieldName:_fieldName
                    });
                    // 初始化表格分页设置
                    tableCheckBoxUtil.init({
                        gridId: 'ID_'+config.table_class
                        , filterId: config.table_class+'_filter'
                        , fieldName:_fieldName//checkbox选择指定字段表
                    });
                }
            }

            //检测列全选功能对应的字段是否有选择，如果存在，标记对应列的过滤状态
            function checkFilterCheckboxState() {
                that.find('.layui-filter-condition .filter-checkbox-input input').each(function(i, d) {
                    var _name = d.name.replace(/--input/ig,'')
                    if(d.value){
                        that.find('.layui-table-filter[type="'+_name+'"]').addClass('checked-filter-on');
                    }else{
                        that.find('.layui-table-filter[type="'+_name+'"]').removeClass('checked-filter-on');
                    }
                })
            }

            /**
             * 监听排序，由服务器端发送排序请求
             * table.render 中需禁用前端自动排序，autoSort: false
             */
            table.on('sort(' + config.table_class + '_filter)', function(obj) {
                console.log('%c that', 'background:red',config.table_class)
                //显示筛选条件层
                if (config.filterHead && that.find('.layui-filter-condition:hidden')) {
                    that.find('.layui-filter-condition').show();
                }
                _columnName = obj.field;
                var _sortType;
                switch (obj.type) {
                    case 'asc':
                        _sortType = '升序';
                        break;
                    case 'desc':
                        _sortType = '降序';
                        break;
                    default:
                        _sortType = '';
                }
                var _S = that.find('.layui-filter-condition .sort-c p label[data-name="' + _columnName + '"]');
                if (_S.length > 0) {
                    _S.data('sort', obj.type);
                    _S.find('.sort').html(_sortType);
                } else {
                    $('.' + config.table_class + ' .sort-c p').html('<label data-name="' + obj.field + '" data-sort="' + obj.type + '">' + obj.field + ' - <span class="sort">' + _sortType + '</span><i class="iconfont del">&#xe7ba;</i></label>');
                }
                if(_sortType == ''){
                    $('.' + config.table_class + ' .sort-c p').html('');
                }
                filterTable(); //查询表格
            });

            /*清除跨页选择已选项*/
            function clearChecked() {
                tableCheckBoxUtil.checkedDefault({
                    gridId: 'ID_' + config.table_class,
                    fieldName: '' /* 显示所有数据，传值fieldName为空，即可清除保存的table数据勾选项 */
                });                
            }

            /*关闭弹层*/
            $('.table-containter').on('click','.close',function(){
                closeMytableFilterPopup();  
            })

        })
    };
});